home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / minix / up1510b.tgz / up1510b / doc / net.doc < prev    next >
Text File  |  1990-07-19  |  44KB  |  841 lines
  1.                         MINIX NETWORKING
  2.  
  3. 1. INTRODUCTION
  4.      Network software can be divided into two general categories differing
  5. in the way the software is integrated into the operating system and the user
  6. software.  When networks first developed, they were used over slow wide-area
  7. links (56 kbps or less), so the designers' main concern was using the 
  8. available bandwidth efficiently.  Programmer convenience was not considered.  
  9. Later, as higher bandwidth networks became widespread (especially local area 
  10. networks, such as Ethernet), the focus changed from worrying about bandwidth 
  11. utilization, to worrying about making the network interface convenient for 
  12. the programmers.  This evolution is very similar to the evolution from 
  13. assembly language programming, where the machine came first, to programming 
  14. in high level languages, where the programmer came first.
  15.  
  16.      Networks of the first type of are said to be connection oriented, and use
  17. what are called sliding window protocols.  All older networks, especially
  18. wide area networks, are of this type.  Some of the better known protocols are
  19. X.25, TCP/IP, and OSI.  Networks of the second type are connectionless, and
  20. use what is called remote procedure call (RPC).  Virtually all modern 
  21. distributed operating systems are based on this concept.  Some well-known 
  22. examples are the work of Xerox PARC [1], the V kernel [2], and Amoeba [3-9].
  23. While it is certainly possible to build RPC on top of a connection-oriented
  24. protocol, this approach is inefficient compared to building the RPC on top of
  25. the bare network.  For an introduction to connection-oriented protocols, RPC,
  26. and networking in general, see [10].
  27.  
  28.      Networking in MINIX is based on RPC.  Briefly summarized, communication
  29. between two processes works as follows.  One of the processes, called the
  30. server, has some service to offer, such as a file storage.  The other process,
  31. the client, wants to use this service.  The interface to the service consists
  32. of a collection of procedures that the client can call.  In the case of a file
  33. server, the procedures might be CREATE_FILE, RENAME_FILE, READ_DATA,
  34. WRITE_DATA, and so on.  These are library routines available on the client's
  35. machine.
  36.  
  37.      When the client calls one of these procedures, the procedure sends a
  38. message to the server containing the procedure name and its parameters.  The
  39. procedure then blocks waiting for the reply.  When the message gets to the
  40. server, it is decoded there and executed.  The reply is sent back to the
  41. calling procedure on the client's machine, which then returns the results to
  42. the caller.  From the programmer's point of view, having remote services in the
  43. network essentially means that there is a new collection of procedures to 
  44. call.  The programmer is not burdened with concepts like opening connections,
  45. sending data, or thinking in terms of acknowledgements, all of which are
  46. needed in the connection-oriented model.  Nor is the network software burdened
  47. with having to manage connections.  
  48.  
  49.      In effect, RPC is based on the abstraction of the procedure call, whereas
  50. connection-oriented networks are based on the much lower-level concept of 
  51. making the network look like an input/output device.  While at first glance it 
  52. might seem that connection-oriented networking could be made to fit with the
  53. UNIX/MINIX concept of a pipe, pipes are set up in a very different way (by a
  54. common ancestor), and fit very poorly to the most common style of local area
  55. network programming, where the client has a request and the server gives a 
  56. response.  With wide area networks, this kind of interaction is painfully slow,
  57. due to the low bandwidth, so the only services generally available are mail
  58. and file transfer, which are batch-oriented.  MINIX networking has been
  59. designed for interactive use on high performance local area networks, so for
  60. this reason, RPC has been chosen over the older connection-oriented style.
  61.  
  62.      In particular, MINIX networking has been designed to be compatible with
  63. the form of RPC used in the Amoeba distributed operating system [3-9].  Not
  64. only have the concepts and the implementation been well tested, but the
  65. performance is exceedingly good.  For example, for doing file transfers,
  66. something that connection-oriented protocols are supposed to be good at,
  67. Amoeba running on two Sun 3s achieves triple the throughput of TCP/IP running
  68. on the same hardware.  Data transfers between two Zenith Z-248s running
  69. the Amoeba RPC on MINIX have been measured at 165 kbytes/sec, almost as fast
  70. as TCP/IP transfers between two Sun 3/50s.  Considering that the Suns are
  71. two times as fast as the Z-248s and the network software is 100% CPU
  72. limited (doubling the CPU speed doubles the throughput), this is a strong
  73. argument for the Amoeba RPC.  As a final statistic, the RPC throughput between
  74. a client and server located on the same Z-248 is 1.5 Mbytes/sec, an extremely
  75. high figure for this class of machine, and much better than what Suns and VAXes
  76. normally achieve locally, despite their greater CPU power.  In conclusion,
  77. although RPC was chosen for its elegance and ease of use, it turns out that it
  78. also has excellent performance, even doing things like bulk transfer, and
  79. certainly doing things like short request-reply interactions.
  80.  
  81.      A few words about Amoeba are probably in order here.  It is a distributed 
  82. operating system that was developed at the Vrije Universiteit in Amsterdam and
  83. is now being used there, at the Centre for Mathematics and Computer Science in
  84. Amsterdam, and a number of other research centers in several countries. It is 
  85. written in C and currently runs on a wide variety of microprocessors and 
  86. minicomputers (including the Sun 3, various other MC68020 systems, the PDP 11 
  87. and the DEC Vax).  Note that Amoeba is a complete operating system, just like 
  88. UNIX, MINIX or VMS.  The only relation between Amoeba and MINIX is that MINIX 
  89. networking uses the Amoeba RPC protocols.  Other than that they are quite 
  90. different in structure, funtionality, and goals. Amoeba was designed to run 
  91. on systems consisting of dozens of processors, and yet give the programmer the
  92. illusion that it is a traditional single-CPU time sharing system.  For more
  93. information about Amoeba, see the references.
  94.  
  95.  
  96. 2. OBJECTS
  97.      Amoeba is an object-oriented system, and to a considerable extent this
  98. orientation is reflected in the protocol.  As a consequence, MINIX also
  99. acquires a certain object-orientation.  Very briefly, an object is a programmer
  100. defined abstract data type that has well-defined operations on it.  As an
  101. example, a file server could define file and directory objects, and provide
  102. operations to read and write the file objects, and insert files in, and delete
  103. files from, directory objects.  Clients can perform these operations by doing 
  104. RPCs with the file server.  Henceforth we will adopt the Amoeba terminology and
  105. call these RPCs "transactions."  A transaction consists of a request message
  106. from a client to a server, followed by a reply message from the server back to
  107. the client.
  108.  
  109.      It is up to the writer of each server to decide what kinds of objects the
  110. server will support and what operations will be available on them.  The 
  111. structure of the system guarantees that clients can only perform the 
  112. operations provided by the server.  This style of networking is intended to 
  113. force constraints on programmers, just as high-level languages force 
  114. constraints on former assembly-language programmers.
  115.  
  116.      Objects are normally protected by capabilities, which are currently 128-
  117. bit numbers, although in the the next version of Amoeba (Amoeba 4.0) this will
  118. become 256 bits.  When a client asks a server to create an object, the server
  119. returns a capability for the object.  This capability must be presented by the
  120. client to perform subsequent operations on the object.  In Amoeba, capabilities
  121. are protected crytographically.  Since the MINIX kernel, unlike the Amoeba
  122. kernel, was not designed from scratch as a distributed system, the protection
  123. aspects in MINIX are not fully implemented.
  124.  
  125.      A capability has 4 fields, described below.  These fields are important
  126. because they appear in the Amoeba and